Kurs Komputerowy S
System Symboliczny
Mathematica

Obliczenia numeryczne

Dokladnosc i precyzja

Precision[wartosc]
SetPrecision[wartosc, precyzja]
Accuracy[wartosc]
SetAccuracy[wartosc, dokladnosc]
MachinePrecision

a=Sqrt[2]

Precision[a]

Precision[1.3]

b=1.3`50

Precision[b]

b=Sqrt[2.]

Precision[b]

$MachinePrecision

c=SetPrecision[b,20]

Precision[c]

Accuracy[c]

Accuracy[1.3]

d=1.3``50

Accuracy[d]

Wynik dokladny a przyblizony

wyrazenie // N
N[wyrazenie]
N[wyrazenie, precyzja]
Chop[wyrazenie]

a=Sqrt[2]

b=Sqrt[2.]

a//N

Precision[%]

N[a,50]

Precision[%]

Chop[1.3]

Chop[0.90*10^-10]

Chop[1.0*10^-20]

1.0*10^-20

Fourier[{1,0,3,0,7,0,6,4,1}]

InverseFourier[%]

Chop[%]

Suma i iloczyn elementow ciagu

NSum[wyrazenie, {zmienna, w_pocz, w_konc}]
NProduct[wyrazenie, {zmienna, w_pocz, w_konc}]
Options[polecenie]

NSum[1/(x^2),{x,1,100}]

NSum[1/(x^2),{x,1,Infinity}]

Sum[1/(x^2),{x,1,Infinity}]

N[%]

Options[NSum]

NSum[1/(x^2),{x,1,Infinity},WorkingPrecision->50]

NSum[1/(x^2),{x,1,Infinity},PrecisionGoal->50,WorkingPrecision->20]

Precision[%]

NSum[1/(x^2),{x,1,10},EvaluationMonitor:>Print["x=",x,"   ",N[1/(x^2),10]]]

NSum[1/(x^2),{x,1,10},WorkingPrecision->50,EvaluationMonitor:>Print["x=",x,"   ",N[1/(x^2),10]]]

NProduct[x/(x+1),{x,1,100}]

Product[x/(x+1),{x,1,100}]

N[%]

Options[NProduct]

Rozwiazywanie rownan

NSolve[rown, zmienna]      (*   NSolve[...]≡N[Solve[...]]   *)

eq=(x^2)+4x-3==0
NSolve[eq,x]

Solve[eq,x]

N[%]

Clear[a,b,c]

NSolve[a (x^2)+b x+c==0,x]

FindRoot[wielomian, zmienna]

f=(x^4)-4(x^3)-2(x^2)+5x+1
FindRoot[f,{x,1}]

FindRoot[f,{x,0}]

FindRoot[f,{x,-1}]

Plot[f,{x,-2,2}]

Interpolacja, ekstrapolacja i aproksymacja

Interpolation[dane]
    dane:
        {f1, f2, f3, ...}
        {{x1, f1}, {x2, f2}, {x3, f3}, ...}
        {{{x1, y2, ...}, f1}, {{x2, y2, ...}, f2}, ...}
Interpolation[dane,wartosc]

d={1,5,2,6,3,7,4,8}
fi=Interpolation[d]

fi[2]
fi[2.5]

fi[10]

Plot[fi[x],{x,1,8}]

Show[%,ListPlot[d]]

d={{1,1},{2,5},{3,2},{5,6},{6,3},{8,7},{9,4},{11,8}}
fi=Interpolation[d]

Show[Plot[fi[x],{x,1,11}],ListPlot[d]]

Options[Interpolation]

d={1,5,2,6,3,7,4,8}
f0=Interpolation[d,InterpolationOrder->0];
f1=Interpolation[d,InterpolationOrder->1];
f2=Interpolation[d,InterpolationOrder->2];
f3=Interpolation[d,InterpolationOrder->3];
f4=Interpolation[d,InterpolationOrder->4];
f5=Interpolation[d,InterpolationOrder->5];

GraphicsGrid[{{Plot[f0[x],{x,1,8}],Plot[f1[x],{x,1,8}],Plot[f2[x],{x,1,8}]},{Plot[f3[x],{x,1,8}],Plot[f4[x],{x,1,8}],Plot[f5[x],{x,1,8}]}}]

Fit[dane, funkcja, zmienna]

d={1,5,2,6,3,7,4,8};
f1=Fit[d,{1,x},x]
f2=Fit[d,{1,x,(x^2)},x]
f4=Fit[d,{1,x,(x^2),(x^3),(x^4)},x]
f7=Fit[d,{1,x,(x^2),(x^3),(x^4),(x^5),(x^6),(x^7)},x]

GraphicsGrid[{{Show[Plot[f1,{x,0,9},PlotRange->{{0,9},{-5,15}}],ListPlot[d]],Show[Plot[f2,{x,0,9},PlotRange->{{0,9},{-5,15}}],ListPlot[d]]},{Show[Plot[f4,{x,0,9},PlotRange->{{0,9},{-5,15}}],ListPlot[d]],Show[Plot[f7,{x,0,9},PlotRange->{{0,9},{-5,15}}],ListPlot[d]]}}]

Fit[{1},{1,x,(x^2)},x]

FindFit[dane, funkcja, parametry, zmienna]
FindFit[dane,{funkcja,warunki},parametry,zmienna]

Clear[f]

f[De_,α_,xe_]:=De(((1-Exp[-α(x-xe)]))^2)

funkcja=f[2,0.5,3]

Plot[funkcja,{x,0,10}]

dane=Table[{x,funkcja},{x,1,10}]

ff=Fit[dane,{1,x,(x^2),(x^3),(x^4)},x]

Show[Plot[ff,{x,1,10}],ListPlot[dane]]

ffit=FindFit[dane,a(1-Exp[-b(x-c)])^2,{a,b,c},x]

Show[Plot[f[a,b,c]/.ffit,{x,1,10}],ListPlot[dane]]

ffit=FindFit[dane,{a(1-Exp[-b(x-c)])^2,b>0.3},{a,b,c},x]

Show[Plot[f[a,b,c]/.ffit,{x,1,10}],ListPlot[dane]]

Minimum i maksimum funkcji

FindMinimum[funkcja, {zmienna, wartosc}]
NMinimize[funkcja,zmienna]
FindMaximum[funkcja,{zmienna,wartosc}]
NMaximize[funkcja,zmienna]
Opcje: StepMonitor i EvaluationMonitor

f=(x^4)-4(x^3)-2(x^2)+5x+1
Plot[f,{x,-2,5}]

f=(x^4)-4(x^3)-2(x^2)+5x+1
FindMinimum[f,{x,0}]

FindMinimum[f,{x,3}]

FindMinimum[f,{x,2}]

NMinimize[f,x]

Options[NMinimize]

NMinimize[f,x,Method->"DifferentialEvolution"]

FindMaximum[f,{x,0}]

FindMaximum[f,{x,-1}]

NMaximize[f,x]

i=1;FindMinimum[f,{x,0},StepMonitor:>(Print["i=",i,"  x=",x];i++)]

i=1;FindMinimum[f,{x,0},EvaluationMonitor:>(Print["i=",i,"  x=",x];i++)]

Calkowanie

NIntegrate[funkcja, {zmienna, w_pocz, w_konc}]

NIntegrate[Sin[x],{x,0,1}]

Options[NIntegrate]

NIntegrate[Sin[x]^2Cos[y^2],{x,0,Pi/2},{y,0,Pi/2}]

Rozwiazywanie rownan rozniczkowych

NDSolve[{rownanie,warunki}, funkcja,{zmienna, w_pocz, w_konc}]

DSolve[y'[x]==Cos[x],y[x],x]

r=DSolve[{y'[x]==Cos[x],y[0]==1},y[x],x]

f=y[x]/.r[[1]]

Table[f,{x,0,10}]//N

nr=NDSolve[{y'[x]==Cos[x],y[0]==1},y,{x,0,10}]

Table[y[x]/.nr[[1]],{x,0,10}]

Plot[{f,y[x]/.nr[[1]]},{x,0,10}]

Options[NDSolve]